//总结： initialValue就是最后返回结果的结构一个空结构，如果最后返回一个对象，则是{}；
// 如果返回一个数组，则是[];如果返回一个数字，则是0
// initialValue设置，accumulator初始值就是它

// // 0.reduce 求和
// const sum = [1,2,3,4].reduce((accumulator,currentValue)=>{
//     console.log('accumulator:',accumulator,'currentValue:',currentValue)
//     return accumulator+currentValue
// },10)
// console.log(sum)

// // 1.reduce 案例1
// const names = ["Alice", "Bob", "Tiff", "Bruce", "Alice"];
// const countedNames = names.reduce((allNames, name) => {
//     console.log('allNames',allNames)
//     console.log('f',allNames[name])
//     const currCount = allNames[name] ?? 0;
//     console.log('h',currCount)
//     return {
//         ...allNames,
//         [name]: currCount + 1,
//     };
// });
// // countedNames 的值是：
// // { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }
// console.log(countedNames)


// 案例二
const people = [
    { name: "Alice", age: 21 },
    { name: "Max", age: 20 },
    { name: "Jane", age: 20 },
];

// function groupBy(arr, property) {
//     return arr.reduce((p, v) => {
//         const key = v[property]
//         const curGroup = p[key] ?? []
//         return {
//             ...p,
//             // [key]:[...curGroup,v]
//         }
//     }, {})
// }

// function groupBy(arr, property) {
//     return arr.reduce((p, v) => {
//         const key = v[property]
//         if(!p[key]){
//             p[key] = []
//         }
//         return {
//             ...p,
//             [key]:[...p[key],v]
//             // [key]:p[key].push(v)
//             // [key]:[...p[key]].push(v)

//         }
//     }, {})
// }

// const groupedPeople = groupBy(people, "age");
// console.log(groupedPeople);
// // {
// //   20: [
// //     { name: 'Max', age: 20 },
// //     { name: 'Jane', age: 20 }
// //   ],
// //   21: [{ name: 'Alice', age: 21 }]
// // }


// // 3.数组去重
// const myArray = ["a", "b", "a", "b", "c", "e", "e", "c", "d", "d", "d", "d"];
// let newArr =  myArray.reduce((accumulator,currentValue)=>{
//     if(accumulator.includes(currentValue)){
//         return accumulator
//     }else{
//         return [...accumulator,currentValue]
//     }
// },[])

// console.log(newArr)

// // 4.代替filter和map
// const numbers = [-5, 6, 2, 0];

// let doubledPositiveNumbers = numbers.reduce((accumulator,currentValue)=>{
//     if(currentValue>0){
//         return [...accumulator,currentValue*2]
//     }
//     // 注意对<=0情况的处理，也要返回
//     return accumulator
// },[])
// console.log(doubledPositiveNumbers); // [12, 4]

// 5.按顺序执行Promise
/**
 * 链接一系列 Promise 处理程序。
 *
 * @param {array} arr——一个 Promise 处理程序列表，每个处理程序接收前一个处理程序解决的结果并返回另一个 Promise。
 * @param {*} input——开始调用 Promise 链的初始值
 * @return {Object}——由一系列 Promise 链接而成的 Promise
 */
function runPromiseInSequence(arr, input) {
    return arr.reduce(
        (promiseChain, currentFunction) => promiseChain.then(currentFunction),
        Promise.resolve(input),
    );
}

// Promise 函数 1
function p1(a) {
    return new Promise((resolve, reject) => {
        resolve(a * 5);
    });
}

// Promise 函数 2
function p2(a) {
    return new Promise((resolve, reject) => {
        resolve(a * 2);
        // reject(a * 2);

    });
}

// 函数 3——将由 `.then()` 包装在已解决的 Promise 中
function f3(a) {
    return a * 3;
}

// // Promise 函数 4
// function p4(a) {
//     return new Promise((resolve, reject) => {
//         resolve(a * 4);
//     });
// }

// const promiseArr = [p1, p2, f3, p4];
// // runPromiseInSequence(promiseArr, 10).then(console.log); // 1200


// // 6.实现函数组合管道
// const pipe = (...functions) => num => functions.reduce((acc, fn) => fn(acc), num)
// const double = (x) => x * 2
// const triple = (x) => x * 3
// const quadruple = (x) => x * 4
// // 组合的函数，实现特定值的乘法
// const multiply6 = pipe(double, triple);
// const multiply9 = pipe(triple, triple);
// const multiply16 = pipe(quadruple, quadruple);
// const multiply24 = pipe(double, triple, quadruple);
// // 用例
// console.log(multiply6(6)); // 36


let p = new Promise((resolve,reject)=>{
    reject(1)
    console.log('start')
})
// p.then(res=>console.log('res',res),err=>console.log('err',err))
p.then(res=>console.log('res',res)).catch(err=>console.log('err',err))
